home *** CD-ROM | disk | FTP | other *** search
/ Programmer Power Tools / Programmer Power Tools.iso / pibterm / pibt41s3.arc / PROCESS5.MOD < prev    next >
Encoding:
Text File  |  1988-03-07  |  41.0 KB  |  1,305 lines
  1. (*----------------------------------------------------------------------*)
  2. (*   Directory_Of_Scripts --- Display directory of available scripts    *)
  3. (*----------------------------------------------------------------------*)
  4.  
  5. PROCEDURE Directory_Of_Scripts;
  6.  
  7. (*----------------------------------------------------------------------*)
  8. (*                                                                      *)
  9. (*     Procedure:  Directory_Of_Scripts                                 *)
  10. (*                                                                      *)
  11. (*     Purpose:    Displays directory of scripts                        *)
  12. (*                                                                      *)
  13. (*     Calling Sequence:                                                *)
  14. (*                                                                      *)
  15. (*        Directory_Of_Scripts;                                         *)
  16. (*                                                                      *)
  17. (*     Calls:                                                           *)
  18. (*                                                                      *)
  19. (*        Save_Screen                                                   *)
  20. (*        Draw_Menu_Frame                                               *)
  21. (*        Restore_Screen                                                *)
  22. (*        Reset_Global_Colors                                           *)
  23. (*        Display_Library_Options                                       *)
  24. (*        Display_Script_Options                                        *)
  25. (*        Get_Library_Names                                             *)
  26. (*        Get_Directory_Names                                           *)
  27. (*                                                                      *)
  28. (*----------------------------------------------------------------------*)
  29.  
  30. CONST
  31.    Scripts_Per_Line        = 7;
  32.    Scripts_Per_Page        = 105;
  33.    Scripts_Per_Line_1      = 6;
  34.    Scripts_Per_Page_1      = 104;
  35.    Script_Lines_Per_Page   = 15;
  36.    Script_Lines_Per_Page_1 = 14;
  37.  
  38. TYPE
  39.    Script_Origin_Type     = ( From_Disk, From_Library, From_Memory );
  40.  
  41.    Script_Names_Type      = ARRAY[1..1] OF STRING[8];
  42.    Script_Lib_Origin_Type = ARRAY[1..1] OF Script_Origin_Type;
  43.  
  44.    Script_Names_Type_Ptr  = ^Script_Names_Type;
  45.    Script_Lib_Origin_Ptr  = ^Script_Lib_Origin_Type;
  46.  
  47. VAR
  48.    Local_Save_2      : Saved_Screen_Ptr;
  49.    I                 : INTEGER;
  50.    J                 : INTEGER;
  51.    L                 : INTEGER;
  52.    Ch                : CHAR;
  53.    Script_Title      : AnyStr;
  54.    Quit              : BOOLEAN;
  55.    Script_File_Local : Text_File;
  56.    Top_Script        : INTEGER;
  57.    Bottom_Script     : INTEGER;
  58.    Current_Script    : INTEGER;
  59.    Row               : INTEGER;
  60.    Column            : INTEGER;
  61.    NScripts          : INTEGER;
  62.    Script_Names      : Script_Names_Type_Ptr;
  63.    Script_Lib_Origin : Script_Lib_Origin_Ptr;
  64.    ReDraw            : BOOLEAN;
  65.    Search_String     : STRING[8];
  66.    Recomp            : BOOLEAN;
  67.    Max_Scripts       : INTEGER;
  68.    RMaxScripts       : LONGINT;
  69.  
  70. (*----------------------------------------------------------------------*)
  71. (*   Display_Directory_Options --- Display script processing options    *)
  72. (*----------------------------------------------------------------------*)
  73.  
  74. PROCEDURE Display_Directory_Options;
  75.  
  76. BEGIN (* Display_Directory_Options *)
  77.  
  78.    TextColor( Menu_Text_Color );
  79.  
  80.    GoToXY( 1 , 16 );
  81.    WRITE(' * before script name means script resides in PIBTERM.SCL');
  82.    ClrEol;
  83.    GoToXY( 1 , 17 );
  84.    WRITE(' & before script name means script already compiled to memory');
  85.    ClrEol;
  86.  
  87.    GoToXY( 1 , 19 );
  88.    TextColor( Menu_Frame_Color );
  89.    WRITE('ESC');
  90.    TextColor( Menu_Text_Color  );
  91.    WRITE('    Quit    ');
  92.    TextColor( Menu_Frame_Color );
  93.    WRITE('/');
  94.    TextColor( Menu_Text_Color  );
  95.    WRITE('   Scroll     ');
  96.    TextColor( Menu_Frame_Color );
  97.    WRITE('PgUp/PdDn');
  98.    TextColor( Menu_Text_Color  );
  99.    WRITE('  Page       ');
  100.    TextColor( Menu_Frame_Color );
  101.    WRITE('Home/End  ');
  102.    TextColor( Menu_Text_Color  );
  103.    WRITE('Top/bottom');
  104.    ClrEol;
  105.  
  106.    GoToXY( 1 , 20 );
  107.    TextColor( Menu_Frame_Color );
  108.    WRITE('S      ');
  109.    TextColor( Menu_Text_Color  );
  110.    WRITE('Search  ');
  111.    TextColor( Menu_Frame_Color );
  112.    WRITE('C     ');
  113.    TextColor( Menu_Text_Color  );
  114.    WRITE('Compile    ');
  115.    TextColor( Menu_Frame_Color );
  116.    WRITE('U          ');
  117.    TextColor( Menu_Text_Color  );
  118.    WRITE('Unload     ');
  119.    TextColor( Menu_Frame_Color );
  120.    WRITE('L         ');
  121.    TextColor( Menu_Text_Color  );
  122.    IF ( NOT Script_Learn_Mode ) THEN
  123.       WRITE('Learn')
  124.    ELSE
  125.       WRITE( 'Finish learn' );
  126.    ClrEol;
  127. {
  128.    GoToXY( 1 , 21 );
  129.    TextColor( Menu_Frame_Color );
  130.    WRITE('ENTER  ');
  131.    TextColor( Menu_Text_Color  );
  132.    WRITE('execute script           ');
  133. }
  134.    GoToXY( 1 , 21 );
  135.    TextColor( Menu_Frame_Color );
  136.    WRITE('ENTER  ');
  137.    TextColor( Menu_Text_Color  );
  138.    WRITE('execute ');
  139.    TextColor( Menu_Frame_Color );
  140.    WRITE('A');
  141.    TextColor( Menu_Text_Color  );
  142.    WRITE('     Unload all ');
  143.    TextColor( Menu_Frame_Color );
  144.    WRITE('O          ');
  145.    TextColor( Menu_Text_Color  );
  146.    WRITE('Change search order (now ');
  147.    CASE Script_Search_Order OF
  148.       Dir_Then_Lib:  WRITE('DL');
  149.       Lib_Then_Dir:  WRITE('LD');
  150.       Dir_Only    :  WRITE('D ');
  151.       Lib_Only    :  WRITE('L ');
  152.    END (* CASE *);
  153.    WRITE(')');
  154.    ClrEol;
  155.  
  156. END   (* Display_Directory_Options *);
  157.  
  158. (*----------------------------------------------------------------------*)
  159. (*          Get_Library_Names --- Get script names in PIBTERM.SCL       *)
  160. (*----------------------------------------------------------------------*)
  161.  
  162. PROCEDURE Get_Library_Names;
  163.  
  164. VAR
  165.    Quit  : BOOLEAN;
  166.    SName : STRING[8];
  167.  
  168. BEGIN (* Get_Library_Names *)
  169.                                    (* Open script library file *)
  170.       (*!I-*)
  171.    ASSIGN( Script_File_Local , Home_Dir + 'PIBTERM.SCL' );
  172.    RESET ( Script_File_Local );
  173.       (*!I+*)
  174.                                    (* Error if it can't be opened *)
  175.    IF ( Int24Result <> 0 ) THEN
  176.       BEGIN
  177.             (*!I-*)
  178.          CLOSE( Script_File_Local );
  179.             (*!I+*)
  180.          I := Int24Result;
  181.          EXIT;
  182.       END;
  183.                                    (* Loop over script library lines *)
  184.                                    (* and extract script names.      *)
  185.    Quit := FALSE;
  186.  
  187.    REPEAT
  188.  
  189.       READLN( Script_File_Local , Script_Line );
  190.  
  191.       IF ( LENGTH( Script_Line ) > 1 ) THEN
  192.          IF ( COPY( Script_Line, 1, 2 ) = '==' ) THEN
  193.             BEGIN
  194.  
  195.                SName    := COPY( Script_Line, 3, LENGTH( Script_Line ) - 2 );
  196.                SName    := SName + Dupl( ' ' , 8 - LENGTH( SName ) );
  197.  
  198.                IF ( NScripts >= Max_Scripts ) THEN
  199.                   Quit := TRUE
  200.                ELSE
  201.                   BEGIN
  202.                      INC( NScripts );
  203.                      Script_Names^[NScripts]      := SName;
  204.                      Script_Lib_Origin^[NScripts] := From_Library;
  205.                   END;
  206.  
  207.             END;
  208.  
  209.    UNTIL ( EOF( Script_File_Local ) OR Quit );
  210.  
  211.                                    (* Close script library file *)
  212.       (*!I-*)
  213.    CLOSE( Script_File_Local );
  214.       (*!I+*)
  215.    I := Int24Result;
  216.  
  217. END   (* Get_Library_Names *);
  218.  
  219. (*----------------------------------------------------------------------*)
  220. (*   Get_Directory_Names --- Get script names in script directory       *)
  221. (*----------------------------------------------------------------------*)
  222.  
  223. PROCEDURE Get_Directory_Names;
  224.  
  225. VAR
  226.    Quit         : BOOLEAN;
  227.    File_Entry   : SearchRec;
  228.    SName        : STRING[8];
  229.    Script_P     : AnyStr;
  230.    I            : INTEGER;
  231.  
  232. BEGIN (* Get_Directory_Names *)
  233.                                    (* Script path *)
  234.  
  235.    Script_P := Script_Path + '*.SCR';
  236.  
  237.                                    (* See if any scripts at all *)
  238.  
  239.    FindFirst( Script_P, AnyFile, File_Entry );
  240.  
  241.    Quit     := ( DosError <> 0 );
  242.  
  243.    IF ( Quit AND ( NScripts = 0 ) ) THEN
  244.       BEGIN
  245.          GoToXY( 1 , 1 );
  246.          WRITE('No scripts at all!');
  247.          ClrEol;
  248.       END;
  249.                                    (* Get all scripts in directory *)
  250.    WHILE( NOT Quit ) DO
  251.       BEGIN
  252.                                    (* Get file name *)
  253.  
  254.          IF ( Nscripts > Max_Scripts ) THEN
  255.             Quit := TRUE
  256.          ELSE
  257.             WITH File_Entry DO
  258.                BEGIN
  259.                   INC( NScripts );
  260.                   SName     := COPY( Name, 1, PRED( POS( '.' , Name ) ) );
  261.                   SName     := SName + Dupl( ' ' , 8 - LENGTH( SName ) );
  262.                   Script_Names^[NScripts]      := SName;
  263.                   Script_Lib_Origin^[NScripts] := From_Disk;
  264.                END;
  265.                                    (* See if more scripts *)
  266.  
  267.          FindNext( File_Entry );
  268.  
  269.          Quit := Quit OR ( DosError <> 0 );
  270.  
  271.       END (* WHILE *);
  272.  
  273. END   (* Get_Directory_Names *);
  274.  
  275. (*----------------------------------------------------------------------*)
  276. (*   Get_Compiled_Names --- Get script names already compiled to memory *)
  277. (*----------------------------------------------------------------------*)
  278.  
  279. PROCEDURE Get_Compiled_Names;
  280.  
  281. VAR
  282.    SName        : STRING[8];
  283.    I            : INTEGER;
  284.    Quit         : BOOLEAN;
  285.  
  286. BEGIN (* Get_Compiled_Names *)
  287.  
  288.    Quit := FALSE;
  289.    I    := 0;
  290.  
  291.    WHILE ( NOT Quit ) DO
  292.       BEGIN
  293.  
  294.          INC( I );
  295.  
  296.          IF ( I > Script_Count ) THEN
  297.             Quit:= TRUE
  298.          ELSE
  299.             BEGIN
  300.  
  301.                INC( NScripts );
  302.  
  303.                IF ( NScripts > Max_Scripts ) THEN
  304.                   Quit := TRUE
  305.                ELSE
  306.                   BEGIN
  307.                      SName := Scripts[I].Script_Name;
  308.                      Script_Names^[NScripts] := Sname +
  309.                         Dupl( ' ' , 8 - LENGTH( SName ) );
  310.                      Script_Lib_Origin^[NScripts] := From_Memory;
  311.                   END;
  312.  
  313.             END;
  314.  
  315.       END;
  316.  
  317. END   (* Get_Compiled_Names *);
  318.  
  319. (*----------------------------------------------------------------------*)
  320. (*             Sort_Script_Names --- Sort the script names              *)
  321. (*----------------------------------------------------------------------*)
  322.  
  323. PROCEDURE Sort_Script_Names;
  324.  
  325. VAR
  326.    I     : INTEGER;
  327.    J     : INTEGER;
  328.    SName : STRING[8];
  329.    B     : Script_Origin_Type;
  330.    D     : INTEGER;
  331.  
  332. BEGIN (* Sort_Script_Names *)
  333.                                    (* This is a shell sort *)
  334.    D := NScripts;
  335.  
  336.    WHILE( D > 1 ) DO
  337.       BEGIN
  338.  
  339.          IF ( D < 5 ) THEN
  340.             D := 1
  341.          ELSE
  342.             D := TRUNC( 0.45454 * D );
  343.  
  344.          FOR I := ( NScripts - D ) DOWNTO 1 DO
  345.             BEGIN
  346.  
  347.                SName := Script_Names^[I];
  348.                B     := Script_Lib_Origin^[I];
  349.                J     := I + D;
  350.  
  351.                WHILE( ( SName > Script_Names^[J] ) AND ( J <= NScripts ) ) DO
  352.                   BEGIN
  353.                      Script_Names^[J-D]      := Script_Names^[J];
  354.                      Script_Lib_Origin^[J-D] := Script_Lib_Origin^[J];
  355.                      J                       := J + D;
  356.                   END;
  357.  
  358.                Script_Names^[J-D]      := SName;
  359.                Script_Lib_Origin^[J-D] := B;
  360.  
  361.             END;
  362.  
  363.       END;
  364.  
  365. END   (* Sort_Script_Names *);
  366.  
  367. (*----------------------------------------------------------------------*)
  368. (*             Emphasize --- Emphasize current script name              *)
  369. (*----------------------------------------------------------------------*)
  370.  
  371. PROCEDURE Emphasize;
  372.  
  373. BEGIN (* Emphasize *)
  374.  
  375.    IF ( NScripts > 0 ) THEN
  376.       BEGIN
  377.  
  378.          RvsVideoOn( Menu_Text_Color, BLACK );
  379.  
  380.          GoToXY( ( Column - 1 ) * 10 + 1 , Row );
  381.  
  382.          CASE Script_Lib_Origin^[Current_Script] OF
  383.             From_Library: WRITE( ' *');
  384.             From_Disk   : WRITE( '  ');
  385.             From_Memory : WRITE( ' &');
  386.          END (* CASE *);
  387.  
  388.          WRITE( Script_Names^[Current_Script] );
  389.  
  390.          RvsVideoOff( Menu_Text_Color, BLACK );
  391.  
  392.       END;
  393.  
  394. END   (* Emphasize *);
  395.  
  396. (*----------------------------------------------------------------------*)
  397. (*             UnEmphasize --- Unemphasize current script name          *)
  398. (*----------------------------------------------------------------------*)
  399.  
  400. PROCEDURE Unemphasize;
  401.  
  402. BEGIN (* Unemphasize *)
  403.  
  404.    IF ( NScripts > 0 ) THEN
  405.       BEGIN
  406.  
  407.          GoToXY( ( Column - 1 ) * 10 + 1 , Row );
  408.  
  409.          CASE Script_Lib_Origin^[Current_Script] OF
  410.             From_Library: WRITE( ' *');
  411.             From_Disk   : WRITE( '  ');
  412.             From_Memory : WRITE( ' &');
  413.          END (* CASE *);
  414.  
  415.          WRITE( Script_Names^[Current_Script] );
  416.  
  417.       END;
  418.  
  419. END   (* Unemphasize *);
  420.  
  421. (*----------------------------------------------------------------------*)
  422. (*             Display_A_Line --- Display one line in script list       *)
  423. (*----------------------------------------------------------------------*)
  424.  
  425. PROCEDURE Display_A_Line( LineNo : INTEGER; Top: INTEGER );
  426.  
  427. VAR
  428.    I: INTEGER;
  429.    N: INTEGER;
  430.  
  431. BEGIN (* Display_A_Line *)
  432.  
  433.    GoToXY( 1 , LineNo );
  434.  
  435.    N := MIN( NScripts , Top + Scripts_Per_Line_1 );
  436.  
  437.    FOR I := Top TO N DO
  438.       BEGIN
  439.  
  440.          CASE Script_Lib_Origin^[I] OF
  441.             From_Library: WRITE( ' *');
  442.             From_Disk   : WRITE( '  ');
  443.             From_Memory : WRITE( ' &');
  444.          END (* CASE *);
  445.  
  446.          WRITE( Script_Names^[I] );
  447.  
  448.       END;
  449.  
  450.    ClrEol;
  451.  
  452. END   (* Display_A_Line *);
  453.  
  454. (*----------------------------------------------------------------------*)
  455. (*               Scroll_Up --- Scroll up a line in display              *)
  456. (*----------------------------------------------------------------------*)
  457.  
  458. PROCEDURE Scroll_Up;
  459.  
  460. VAR
  461.    L: INTEGER;
  462.  
  463. BEGIN (* Scroll_Up *)
  464.  
  465.    IF ( Bottom_Script < NScripts ) THEN
  466.       BEGIN
  467.  
  468.          Emphasize;
  469.                                    (* Make room for new line *)
  470.          GoToXY( 1 , 1 );
  471.          DelLine;
  472.  
  473.          Top_Script     := MIN( NScripts , Top_Script     + Scripts_Per_Line_1 );
  474.          Bottom_Script  := MIN( NScripts , Bottom_Script  + Scripts_Per_Line_1 );
  475.          Current_Script := MIN( NScripts , Current_Script + Scripts_Per_Line_1 );
  476.  
  477.          L             := ( ( Bottom_Script - Top_Script ) +
  478.                             Scripts_Per_Line_1 ) DIV Scripts_Per_Line;
  479.  
  480.          Display_A_Line(  L , ( L - 1 ) * Scripts_Per_Line + 1 );
  481.  
  482.          UnEmphasize;
  483.  
  484.       END;
  485.  
  486. END   (* Scroll_Up *);
  487.  
  488. (*----------------------------------------------------------------------*)
  489. (*               Scroll_Down --- Scroll down a line in display          *)
  490. (*----------------------------------------------------------------------*)
  491.  
  492. PROCEDURE Scroll_Down;
  493.  
  494. BEGIN (* Scroll_Down *)
  495.  
  496.    IF ( Top_Script > 1 ) THEN
  497.       BEGIN
  498.  
  499.          UnEmphasize;
  500.                                    (* Make room for new line *)
  501.          GoToXY( 1 , 1 );
  502.          InsLine;
  503.  
  504.          Top_Script     := MAX( 1 , Top_Script     - Scripts_Per_Line_1 );
  505.          Bottom_Script  := MAX( 1 , Bottom_Script  - Scripts_Per_Line_1 );
  506.          Current_Script := MAX( 1 , Current_Script - Scripts_Per_Line_1 );
  507.  
  508.          Display_A_Line( 1 , Top_Script );
  509.  
  510.          Emphasize;
  511.  
  512.       END;
  513.  
  514. END   (* Scroll_Down *);
  515.  
  516. (*----------------------------------------------------------------------*)
  517. (*                 Move_Up --- Move up a line in display                *)
  518. (*----------------------------------------------------------------------*)
  519.  
  520. PROCEDURE Move_Up;
  521.  
  522. BEGIN (* Move_Up *)
  523.                                    (* Scroll down if at top line *)
  524.    IF ( Row = 1 ) THEN
  525.       Scroll_Down
  526.    ELSE
  527.       IF ( ( Current_Script - Scripts_Per_Line ) >= 1 ) THEN
  528.          BEGIN
  529.             Unemphasize;
  530.             DEC( Row );
  531.             Current_Script := MAX( 1 , Current_Script - Scripts_Per_Line );
  532.             Emphasize;
  533.          END;
  534.  
  535. END   (* Move_Up *);
  536.  
  537. (*----------------------------------------------------------------------*)
  538. (*                 Move_Down --- Move down a line in display            *)
  539. (*----------------------------------------------------------------------*)
  540.  
  541. PROCEDURE Move_Down;
  542.  
  543. BEGIN (* Move_Down *)
  544.                                    (* Scroll up if at bottom line *)
  545.  
  546.    IF ( Row = Script_Lines_Per_Page ) THEN
  547.       Scroll_Up
  548.    ELSE
  549.       IF ( ( Current_Script + Scripts_Per_Line ) <= NScripts ) THEN
  550.          BEGIN
  551.             Unemphasize;
  552.             INC( Row );
  553.             Current_Script := MIN( NScripts ,
  554.                                    Current_Script + Scripts_Per_Line );
  555.             Emphasize;
  556.          END;
  557.  
  558. END   (* Move_Down *);
  559.  
  560. (*----------------------------------------------------------------------*)
  561. (*                  Move_Left --- Move left in script list              *)
  562. (*----------------------------------------------------------------------*)
  563.  
  564. PROCEDURE Move_Left;
  565.  
  566. BEGIN (* Move_Left *)
  567.  
  568.    IF ( Current_Script > 1 ) THEN
  569.       IF ( Column = 1 ) THEN
  570.          IF ( Row = 1 ) THEN
  571.             Move_Up
  572.          ELSE
  573.             BEGIN
  574.                UnEmphasize;
  575.                DEC( Row );
  576.                Column         := Scripts_Per_Line;
  577.                DEC( Current_Script );
  578.                Emphasize;
  579.             END
  580.       ELSE
  581.          BEGIN
  582.             UnEmphasize;
  583.             DEC( Column );
  584.             DEC( Current_Script );
  585.             Emphasize;
  586.          END;
  587.  
  588. END   (* Move_Left *);
  589.  
  590. (*----------------------------------------------------------------------*)
  591. (*                  Move_Right --- Move right in script list            *)
  592. (*----------------------------------------------------------------------*)
  593.  
  594. PROCEDURE Move_Right;
  595.  
  596. BEGIN (* Move_Right *)
  597.  
  598.    IF ( Current_Script < NScripts ) THEN
  599.       IF ( Column = Scripts_Per_Line  ) THEN
  600.          IF ( Row = Script_Lines_Per_Page ) THEN
  601.             Move_Down
  602.          ELSE
  603.             BEGIN
  604.                UnEmphasize;
  605.                INC( Row );
  606.                Column         := 1;
  607.                INC( Current_Script );
  608.                Emphasize;
  609.             END
  610.       ELSE
  611.          BEGIN
  612.             UnEmphasize;
  613.             INC( Column );
  614.             INC( Current_Script );
  615.             Emphasize;
  616.          END;
  617.  
  618. END   (* Move_Right *);
  619.  
  620. (*----------------------------------------------------------------------*)
  621. (* Sync_Current_Script --- Synchronize positioning for current script   *)
  622. (*----------------------------------------------------------------------*)
  623.  
  624. PROCEDURE Sync_Current_Script;
  625.  
  626. BEGIN (* Sync_Current_Script *)
  627.  
  628.    Row            := ( Current_Script - Top_Script ) DIV
  629.                      Scripts_Per_Line + 1;
  630.    Column         := ( Current_Script - Top_Script ) MOD Scripts_Per_Line + 1;
  631.  
  632. END   (* Sync_Current_Script *);
  633.  
  634. (*----------------------------------------------------------------------*)
  635. (*            Search_For_Script --- Search for string in script name    *)
  636. (*----------------------------------------------------------------------*)
  637.  
  638. PROCEDURE Search_For_Script;
  639.  
  640. VAR
  641.    Local_Save_5 : Saved_Screen_Ptr;
  642.    I            : INTEGER;
  643.    Found        : BOOLEAN;
  644.    J            : INTEGER;
  645.    K            : INTEGER;
  646.    SName        : STRING[8];
  647.  
  648. BEGIN (* Search_For_Script *)
  649.  
  650.    Save_Partial_Screen( Local_Save_5, 10, 10, 65, 14 );
  651.  
  652.    PibTerm_Window( 1, 1, 80, 25 );
  653.  
  654.    Draw_Menu_Frame( 10, 10, 65, 14, Menu_Frame_Color, Menu_Title_Color,
  655.                     Menu_Text_Color, 'Search for script');
  656.  
  657.    GoToXY( 1 , 1 );
  658.  
  659.    WRITE('String to search for? ');
  660.  
  661.    SName := '';
  662.    Read_Edited_String( SName );
  663.  
  664.    IF LENGTH( SName ) > 0 THEN
  665.       Search_String := UpperCase( SName );
  666.  
  667.    IF LENGTH( Search_String ) <= 0 THEN
  668.       BEGIN
  669.          Restore_Screen( Local_Save_5 );
  670.          EXIT;
  671.       END;
  672.  
  673.    Found := FALSE;
  674.    I     := SUCC( Current_Script );
  675.    K     := 0;
  676.  
  677.    REPEAT
  678.  
  679.       IF ( POS( Search_String , Script_Names^[I] ) > 0 ) THEN
  680.          BEGIN
  681.  
  682.             Found   := TRUE;
  683.  
  684.             Restore_Screen( Local_Save_5 );
  685.  
  686.             UnEmphasize;
  687.  
  688.             Current_Script := I;
  689.  
  690.             IF ( ( I < Top_Script ) OR ( I > Bottom_Script ) ) THEN
  691.                BEGIN
  692.                   ReDraw         := TRUE;
  693.                   J              := ( I - 1 ) DIV Scripts_Per_Line + 1;
  694.                   Top_Script     := MAX( 1 , ( J - 1 ) * Scripts_Per_Line );
  695.                END;
  696.  
  697.             Sync_Current_Script;
  698.  
  699.          END;
  700.  
  701.       INC( I );
  702.  
  703.       IF ( I > NScripts ) THEN
  704.          I := 1;
  705.  
  706.       INC( K );
  707.  
  708.    UNTIL ( FOUND OR ( K > NScripts ) );
  709.  
  710.    IF ( NOT Found ) THEN
  711.       BEGIN
  712.          WRITELN;
  713.          WRITE('String not found.');
  714.          Window_Delay;
  715.          Restore_Screen( Local_Save_5 );
  716.       END;
  717.  
  718. END   (* Search_For_Script *);
  719.  
  720. (*----------------------------------------------------------------------*)
  721. (*    Change_Script_Search_Order --- Change order for script search     *)
  722. (*----------------------------------------------------------------------*)
  723.  
  724. PROCEDURE Change_Script_Search_Order;
  725.  
  726. VAR
  727.    Search_Menu  : Menu_Type;
  728.    Default      : INTEGER;
  729.  
  730. CONST
  731.    Quit_Item = 5;
  732.  
  733. BEGIN (* Change_Script_Search_Order *)
  734.  
  735.    Default := SUCC( ORD( Script_Search_Order ) );
  736.  
  737.    Make_And_Display_Menu( Search_Menu, Quit_Item, 10, 30, 0, 0, Default,
  738.                           'Order to search for script: ',
  739.                           'Directory then library;Library then directory;' +
  740.                           'Directory only;Library only;Quit;',
  741.                           TRUE, TRUE, I );
  742.  
  743.    IF ( I > 0 ) THEN
  744.       BEGIN
  745.  
  746.          CASE I OF
  747.             1: Script_Search_Order := Dir_Then_Lib;
  748.             2: Script_Search_Order := Lib_Then_Dir;
  749.             3: Script_Search_Order := Dir_Only;
  750.             4: Script_Search_Order := Lib_Only;
  751.          END (* CASE *);
  752.  
  753.          IF ( I <> Default ) THEN
  754.             Display_Directory_Options;
  755.  
  756.       END;
  757.  
  758. END   (* Change_Script_Search_Order *);
  759.  
  760. (*----------------------------------------------------------------------*)
  761. (*            Compile_The_Script --- Compile a script                   *)
  762. (*----------------------------------------------------------------------*)
  763.  
  764. PROCEDURE Compile_The_Script;
  765.  
  766. VAR
  767.    I                 : INTEGER;
  768.    Skip_It           : BOOLEAN;
  769.    Skip_Low          : INTEGER;
  770.    Skip_High         : INTEGER;
  771.  
  772. BEGIN (* Compile_The_Script *)
  773.  
  774.    IF ( Script_Lib_Origin^[Current_Script] <> From_Memory ) THEN
  775.       BEGIN (* Compile a script *)
  776.  
  777.          Script_File_Name := Script_Names^[Current_Script];
  778.  
  779.          Skip_It   := FALSE;
  780.  
  781.          Skip_Low  := MAX( Current_Script - 2 , 1 );
  782.          Skip_High := MIN( Current_Script + 2 , NScripts );
  783.  
  784.          FOR I := Skip_Low TO Skip_High DO
  785.             IF ( Script_Names^[I]      = Script_File_Name ) AND
  786.                ( Script_Lib_Origin^[I] = From_Memory      ) THEN
  787.                Skip_It := TRUE;
  788.  
  789.          IF ( Script_Lib_Origin^[Current_Script] = From_Library ) THEN
  790.             Script_File_Name := '*' + Script_File_Name;
  791.  
  792.          Script_File_Name := TRIM( Script_File_Name );
  793.  
  794.          Compile_Script;
  795.  
  796.          IF ( ( NOT Skip_It ) AND Script_File_Mode ) THEN
  797.             BEGIN
  798.                INC( NScripts );
  799.                Script_Names^[NScripts]      := Script_Names^[Current_Script];
  800.                Script_Lib_Origin^[NScripts] := From_Memory;
  801.                Sort_Script_Names;
  802.                ReDraw := TRUE;
  803.             END;
  804.  
  805.          Script_File_Mode := FALSE;
  806.  
  807.          TextColor     ( Menu_Text_Color );
  808.          TextBackGround( BLACK );
  809.  
  810.       END   (* Compile a script *)
  811.    ELSE
  812.       Menu_Beep;
  813.  
  814. END   (* Compile_The_Script *);
  815.  
  816. (*----------------------------------------------------------------------*)
  817. (*            Get_Script_Names --- Get names of scripts                 *)
  818. (*----------------------------------------------------------------------*)
  819.  
  820. PROCEDURE Get_Script_Names;
  821.  
  822. BEGIN (* Get_Script_Names *)
  823.                                    (* No scripts yet *)
  824.    NScripts := 0;
  825.                                    (* Get names from library *)
  826.  
  827.    IF ( Script_Search_Order <> Dir_Only ) THEN
  828.       Get_Library_Names;
  829.                                    (* Get names from disk *)
  830.    Get_Directory_Names;
  831.                                    (* Get names from memory *)
  832.    Get_Compiled_Names;
  833.                                    (* Sort names *)
  834.    Sort_Script_Names;
  835.  
  836.    Top_Script     := 1;
  837.    Current_Script := 1;
  838.    Column         := 1;
  839.    Row            := 1;
  840.    ReDraw         := TRUE;
  841.  
  842. END   (* Get_Script_Names *);
  843.  
  844. (*----------------------------------------------------------------------*)
  845.  
  846. BEGIN (* Directory_Of_Scripts *)
  847.                                    (* Save current screen *)
  848.    Save_Screen( Local_Save_2 );
  849.                                    (* Get title *)
  850.  
  851.    Script_Title := 'Script Directory';
  852.  
  853.                                    (* Script menu display *)
  854.  
  855.    Draw_Menu_Frame( 1, 1, 80, 24, Menu_Frame_Color, Menu_Title_Color,
  856.                     Menu_Text_Color, Script_Title );
  857.  
  858.    PibTerm_Window( 2, 2, 78, 23 );
  859.  
  860.    TextBackGround( BLACK );
  861.                                    (* Options for script menu *)
  862.    Display_Directory_Options;
  863.                                    (* Figure out how many names can *)
  864.                                    (* be stored.                    *)
  865.  
  866.    RMaxScripts := ( MaxAvail - 4096 ) DIV 10;
  867.  
  868.    IF ( RmaxScripts >= 512 ) THEN
  869.       Max_Scripts := 512
  870.    ELSE
  871.       Max_Scripts := RMaxScripts;
  872.  
  873.    IF ( Max_Scripts <= 0 ) THEN
  874.       BEGIN
  875.          GoToXY( 1 , 1 );
  876.          WRITELN('Not enough memory to display scripts.');
  877.          Press_Any;
  878.          Restore_Screen_And_Colors( Local_Save_2 );
  879.          EXIT;
  880.       END
  881.    ELSE
  882.       BEGIN
  883.          GETMEM( Script_Names      , 9 * Max_Scripts );
  884.          GETMEM( Script_Lib_Origin , Max_Scripts     );
  885.       END;
  886.                                    (* == Get script names == *)
  887.    Get_Script_Names;
  888.                                    (* Begin script name display loop *)
  889.  
  890.    Quit           := FALSE;
  891.    Search_String  := '';
  892.  
  893.    REPEAT
  894.                                    (* Display current page          *)
  895.  
  896.       Top_Script     := MAX( MIN( Top_Script , NScripts ) , 1 );
  897.       Bottom_Script  := MIN( Top_Script + Scripts_Per_Page_1 , NScripts );
  898.       Current_Script := MIN( Current_Script , NScripts );
  899.  
  900.       Sync_Current_Script;
  901.  
  902.       IF Redraw THEN
  903.          FOR L := 0 TO Script_Lines_Per_Page_1 DO
  904.              Display_A_Line( SUCC( L ) , L * Scripts_Per_Line + 1 );
  905.  
  906.       Emphasize;
  907.                                    (* Assume no need to redraw screen *)
  908.       Redraw := FALSE;
  909.                                    (* Read command                  *)
  910.       Read_Kbd_Old( Ch );
  911.  
  912.       IF ( ORD( Ch ) = ESC ) AND ( NOT PibTerm_KeyPressed ) THEN
  913.          Quit := TRUE
  914.       ELSE
  915.          BEGIN
  916.  
  917.             IF ( ORD( Ch ) = ESC ) THEN
  918.                BEGIN
  919.  
  920.                   Read_Kbd_Old( Ch );
  921.  
  922.                   CASE ORD( Ch ) OF
  923.  
  924.                      L_Arrow:  BEGIN (* Left arrow -- move to left *)
  925.                                   Move_Left;
  926.                                END;
  927.  
  928.                      R_Arrow:  BEGIN (* Right arrow -- move to right *)
  929.                                   Move_Right;
  930.                                END;
  931.  
  932.                      U_Arrow:  BEGIN (* Up Arrow -- scroll up one line *)
  933.                                   Move_Up;
  934.                                END   (* Up Arrow *);
  935.  
  936.                      D_Arrow:  BEGIN (* Down Arrow -- scroll down one line *)
  937.                                   Move_Down;
  938.                                END   (* Down Arrow *);
  939.  
  940.                      PgUp:     BEGIN (* PgUp -- move up one page *)
  941.  
  942.                                   IF ( Top_Script > 1 ) THEN
  943.                                      BEGIN
  944.                                         Redraw     := TRUE;
  945.                                         Top_Script := MAX( Top_Script -
  946.                                                            Scripts_Per_Page + 1 , 1 );
  947.                                         Current_Script := MAX( Current_Script -
  948.                                                                Scripts_Per_Page + 1 , 1 );
  949.                                      END;
  950.  
  951.                                END   (* PgUp *);
  952.  
  953.                      PgDn:     BEGIN (* PgDn -- move down one page *)
  954.  
  955.                                   IF ( SUCC( Bottom_Script ) < NScripts ) THEN
  956.                                      BEGIN
  957.                                         Redraw         := TRUE;
  958.                                         Top_Script     := SUCC( Bottom_Script );
  959.                                         Current_Script := MAX( Current_Script +
  960.                                                                Scripts_Per_Page - 1 , 1 );
  961.                                      END;
  962.  
  963.                                END   (* PgDn *);
  964.  
  965.                      Home:     BEGIN (* Home -- move to top of buffer *)
  966.  
  967.                                   Top_Script     := 1;
  968.                                   Current_Script := 1;
  969.                                   Redraw         := TRUE;
  970.  
  971.                                END   (* Home *);
  972.  
  973.                      End_Key:  BEGIN (* End -- move to end of buffer *)
  974.                                   Bottom_Script  := NScripts;
  975.                                   Current_Script := NScripts;
  976.                                   Top_Script     := MAX( Bottom_Script -
  977.                                                          Scripts_Per_Page + 1 , 1 );
  978.                                   Redraw         := TRUE;
  979.                                END   (* End *);
  980.  
  981.                      ELSE                (* Sound bell for bad input *)
  982.  
  983.                                Menu_Beep;
  984.  
  985.                   END (* CASE *);
  986.  
  987.                END (* Ch = ESC *)
  988.             ELSE
  989.                CASE UpCase( Ch ) OF
  990.  
  991.                   ^M:       BEGIN (* Execute chosen script *)
  992.                                Script_File_Name := Script_Names^[Current_Script];
  993.                                IF ( Script_Lib_Origin^[Current_Script] = From_Library ) THEN
  994.                                   Script_File_Name := '*' + Script_File_Name;
  995.                                Recomp := ( Script_Lib_Origin^[Current_Script] <>
  996.                                            From_Memory );
  997.                                Execute_Script( Recomp, Quit );
  998.                                TextColor( Menu_Text_Color );
  999.                                TextBackGround( BLACK );
  1000.                             END   (* Execute chosen script *);
  1001.  
  1002.                   'A':      BEGIN
  1003.                                Unload_All_Scripts;
  1004.                                Get_Script_Names;
  1005.                                TextColor( Menu_Text_Color );
  1006.                                TextBackGround( BLACK );
  1007.                             END;
  1008.  
  1009.                   'C':      Compile_The_Script;
  1010.  
  1011.                   'L':      BEGIN (* Learn a script *)
  1012.                                Learn_Script;
  1013.                                TextColor( Menu_Text_Color );
  1014.                                TextBackGround( BLACK );
  1015.                                Display_Directory_Options;
  1016.                                Quit := ( Script_Learn_Mode );
  1017.                             END   (* Learn a script *);
  1018.  
  1019.                   'O':      BEGIN (* Change script search order *)
  1020.                                Change_Script_Search_Order;
  1021.                             END   (* Change script search order *);
  1022.  
  1023.                   'S':      BEGIN (* Search for script *)
  1024.                                Search_For_Script;
  1025.                             END   (* Search for script *);
  1026.  
  1027.                   'U':      BEGIN (* Unload a script *)
  1028.  
  1029.                                Script_File_Name := TRIM( Script_Names^[Current_Script] );
  1030.  
  1031.                                IF ( Script_Lib_Origin^[Current_Script] = From_Memory) THEN
  1032.                                   BEGIN
  1033.                                      Unload_Script;
  1034.                                      FOR I := SUCC( Current_Script ) TO NScripts DO
  1035.                                          BEGIN
  1036.                                             Script_Names^[I-1]      :=
  1037.                                                Script_Names^[I];
  1038.                                             Script_Lib_Origin^[I-1] :=
  1039.                                                Script_Lib_Origin^[I];
  1040.                                          END;
  1041.                                      TextColor( Menu_Text_Color );
  1042.                                      TextBackGround( BLACK );
  1043.                                      IF ( Current_Script = NScripts ) THEN
  1044.                                         Move_Left;
  1045.                                      NScripts := MAX( PRED( NScripts ) , 0 );
  1046.                                      ReDraw   := TRUE;
  1047.                                   END
  1048.                                ELSE
  1049.                                   Menu_Beep;
  1050.  
  1051.                             END   (* Unload a script *);
  1052.  
  1053.                   ELSE             (* Sound bell for bad input *)
  1054.  
  1055.                             Menu_Beep;
  1056.  
  1057.                END (* CASE *);
  1058.  
  1059.          END;
  1060.  
  1061.    UNTIL Quit;
  1062.  
  1063.    MyFreeMem( Script_Names      , 9 * Max_Scripts );
  1064.    MyFreeMem( Script_Lib_Origin , Max_Scripts     );
  1065.  
  1066.    Restore_Screen_And_Colors( Local_Save_2 );
  1067.  
  1068. END   (* Directory_Of_Scripts *);
  1069.  
  1070. (*----------------------------------------------------------------------*)
  1071. (*             Execute_Keyboard_Command --- Execute keyboard command    *)
  1072. (*----------------------------------------------------------------------*)
  1073.  
  1074. PROCEDURE Execute_Keyboard_Command;
  1075.  
  1076. VAR
  1077.    Save_C25 : ARRAY[1..132] OF CHAR;
  1078.    Save_A25 : ARRAY[1..132] OF BYTE;
  1079.    J        : INTEGER;
  1080.    I        : INTEGER;
  1081.    Ch       : CHAR;
  1082.    Save_WX1 : INTEGER;
  1083.    Save_WX2 : INTEGER;
  1084.    Save_WY1 : INTEGER;
  1085.    Save_WY2 : INTEGER;
  1086.    Save_X   : INTEGER;
  1087.    Save_Y   : INTEGER;
  1088.  
  1089. LABEL 1;
  1090.  
  1091. BEGIN (* Execute_Keyboard_Command *)
  1092.  
  1093.    Save_Do_Status_Time := Do_Status_Time;
  1094.    Do_Status_Time      := FALSE;
  1095.  
  1096.                                    (* Save window positions *)
  1097.  
  1098.    Upper_Left( Save_WX1 , Save_WY1 );
  1099.  
  1100.    Save_WX2 := Lower_Right_Column;
  1101.    Save_WY2 := Lower_Right_Row;
  1102.    Save_X   := WhereX;
  1103.    Save_Y   := WhereY;
  1104.  
  1105.    PibTerm_Window( 1, 1, Max_Screen_Col, Max_Screen_Line );
  1106.  
  1107.    FOR I := 1 TO Max_Screen_Col DO
  1108.       ReadCXY( Save_C25[I], I, Max_Screen_Line, Save_A25[I] );
  1109.  
  1110.                                    (* Prompt for command *)
  1111.  
  1112.    WriteSXY( 'Command: ' + DUPL( ' ' , Max_Screen_Col - 9 ), 1, Max_Screen_Line,
  1113.              Status_Line_Attr );
  1114.  
  1115.    TextColor     ( Status_Line_Attr AND $0F );
  1116.    TextBackGround( Status_Line_Attr SHR 4   );
  1117.  
  1118.    GoToXY( 10 , Max_Screen_Line );
  1119.  
  1120.                                    (* Clear previous text if requested *)
  1121.  
  1122.    IF ( NOT Use_Prev_Key_Text ) THEN
  1123.       Command_Key_Text := '';
  1124.  
  1125.    Ch := Edit_String( Command_Key_Text, 255, 10, 10, Max_Screen_Line,
  1126.                       Max_Screen_Col - 11, FALSE, 0 );
  1127.  
  1128.                                    (* If not quit, then parse command *)
  1129.    IF ( Ch <> CHR( ESC ) ) THEN
  1130.       BEGIN
  1131.                                    (* Push down script stack      *)
  1132.          Push_Current_Script;
  1133.                                    (* Copy command to script line *)
  1134.  
  1135.          Script_Line := Command_Key_Text;
  1136.  
  1137.                                    (* Allocate script buffer *)
  1138.  
  1139.          Script_Buffer_Size := 256;
  1140.          GetMem( Script_Buffer , Script_Buffer_Size );
  1141.  
  1142.                                    (* Make sure we got it *)
  1143.  
  1144.          IF ( Script_Buffer = NIL ) THEN
  1145.             BEGIN
  1146.                WriteSXY( '>>> Not enough memory to process command <<<'
  1147.                          + Dupl( ' ' , Max_Screen_Col - 44 ), 1, Max_Screen_Line,
  1148.                          Status_Line_Attr );
  1149.                Press_Any;
  1150.                Pop_Current_Script;
  1151.                GOTO 1;
  1152.             END;
  1153.                                    (* Current offset in script buffer *)
  1154.  
  1155.          Script_Buffer_Pos     := 0;
  1156.  
  1157.                                    (* No procedures yet defined     *)
  1158.  
  1159.          Script_Proc_Count     := 0;
  1160.          Script_Proc_Start     := 0;
  1161.  
  1162.                                    (* All stacks empty              *)
  1163.  
  1164.          Script_Repeat_Level   := 0;
  1165.          Script_If_Level       := 0;
  1166.          Script_While_Level    := 0;
  1167.          Script_Case_Level     := 0;
  1168.          Script_For_Level      := 0;
  1169.          Script_Proc_Level     := 0;
  1170.  
  1171.                                    (* Script line number            *)
  1172.  
  1173.          Script_Line_Number    := 0;
  1174.  
  1175.                                    (* No variables yet              *)
  1176.  
  1177.          Script_Variable_Kount    := 2;
  1178.          Script_Variable_MaxKount := 2;
  1179.          Script_Variable_Count    := 2;
  1180.          Import_Count             := 0;
  1181.          Script_Debug_Mode        := FALSE;
  1182.  
  1183.                                    (* Check if legitimate command   *)
  1184.  
  1185.          Extract_Script_Command( OK_Script_Command );
  1186.  
  1187.                                    (* If so, generate code for it   *)
  1188.          IF OK_Script_Command THEN
  1189.             Parse_Script_Command  ( OK_Script_Command );
  1190.  
  1191.                                    (* Check if stacks empty.  If not,  *)
  1192.                                    (* error from unclosed loop.        *)
  1193.  
  1194.          OK_Script_Command := OK_Script_Command           AND
  1195.                               ( Script_Repeat_Level = 0 ) AND
  1196.                               ( Script_If_Level     = 0 ) AND
  1197.                               ( Script_Case_Level   = 0 ) AND
  1198.                               ( Script_For_Level    = 0 ) AND
  1199.                               ( Script_While_Level  = 0 ) AND
  1200.                               ( Script_Proc_Level   = 0 );
  1201.  
  1202.          IF ( NOT Ok_Script_Command ) THEN
  1203.             BEGIN
  1204.  
  1205.                WriteSXY( '>>> Bad Command <<<' + Dupl( ' ' , Max_Screen_Col - 19 ),
  1206.                          1, Max_Screen_Line, Status_Line_Attr );
  1207.  
  1208.                Press_Any;
  1209.  
  1210.                Pop_Current_Script;
  1211.  
  1212.             END
  1213.          ELSE
  1214.             BEGIN
  1215.                                    (* Drop exit into table *)
  1216.  
  1217.                Copy_Byte_To_Buffer( ORD( ExitSy ) );
  1218.  
  1219.                                    (* Store command as script *)
  1220.  
  1221.                Script_Short_Name := '!' + Script_Command_Token;
  1222.  
  1223.                Store_Script( Current_Script_Num );
  1224.  
  1225.                                    (* Allocate variables *)
  1226.  
  1227.                Allocate_Script_Variables;
  1228.  
  1229.                                    (* Now point to start of buffer     *)
  1230.  
  1231.                Script_Buffer_Pos       := 0;
  1232.                Script_File_Mode        := TRUE;
  1233.                Script_Command_Key_Mode := TRUE;
  1234.  
  1235.             END;
  1236.  
  1237.       END;
  1238.  
  1239.                                    (* Restore status line *)
  1240. 1:
  1241.    FOR I := 1 TO Max_Screen_Col DO
  1242.       WriteCXY( Save_C25[I], I, Max_Screen_Line, Save_A25[I] );
  1243.  
  1244.                                    (* Restore colors     *)
  1245.    Reset_Global_Colors;
  1246.                                    (* Restore old window *)
  1247.  
  1248.    PibTerm_Window( Save_WX1, Save_WY1, Save_WX2, Save_WY2 );
  1249.    GoToXY( Save_X, Save_Y );
  1250.  
  1251.                                    (* Ensure status line updated *)
  1252.  
  1253.    Do_Status_Time := Save_Do_Status_Time;
  1254.  
  1255.    IF Do_Status_Time THEN
  1256.       BEGIN
  1257.          Current_Status_Time := -1;
  1258.          Update_Status_Line;
  1259.       END;
  1260.  
  1261. END   (* Execute_Keyboard_Command *);
  1262.  
  1263. (*----------------------------------------------------------------------*)
  1264.  
  1265. BEGIN (* Process_Script *)
  1266.                                    (* If script file name defined,   *)
  1267.                                    (* then we're doing it from the   *)
  1268.                                    (* command line or another script *)
  1269.  
  1270.    Use_Script_Library       := FALSE;
  1271.    Script_File_Name         := Script_FName;
  1272.    Script_ComLet            := UpCase( Script_ComLet );
  1273.    Script_File_Name_Given   := ( LENGTH( Script_File_Name ) > 0 );
  1274.  
  1275.                                    (* Choose function *)
  1276.    IF Script_Learn_Mode THEN
  1277.       Learn_Script
  1278.    ELSE
  1279.       CASE Script_ComLet OF
  1280.  
  1281.          'C':  BEGIN
  1282.                   Save_Script_File_Mode := Script_File_Mode;
  1283.                   Push_Current_Script;
  1284.                   Compile_Script;
  1285.                   Pop_Current_Script;
  1286.                   Script_File_Mode := Save_Script_File_Mode;
  1287.                END;
  1288.          'K':  Execute_Keyboard_Command;
  1289.          'L':  Learn_Script;
  1290.          'U':  Unload_Script;
  1291.          ELSE  BEGIN
  1292.                   IF ( NOT Script_Learn_Mode ) THEN
  1293.                      Execute_Script( FALSE , Got_Script )
  1294.                   ELSE
  1295.                      Got_Script := FALSE;
  1296.                   IF ( ( NOT Got_Script ) AND
  1297.                        Attended_Mode      AND
  1298.                        ( NOT Script_File_Name_Given ) ) THEN
  1299.                      Directory_Of_Scripts;
  1300.                END;
  1301.  
  1302.       END (* CASE *);
  1303.  
  1304. END   (* Process_Script *);
  1305.